டைப்ஸ்கிரிப்ட் குறியீடு பகுப்பாய்வு: நிலையான பகுப்பாய்வு வகை வடிவங்கள்

டைப்ஸ்கிரிப்ட், ஜாவாஸ்கிரிப்ட்டின் ஒரு சூப்பர்செட், டைனமிக் உலகிற்கு நிலையான தட்டச்சு கொண்டுவருகிறது. இது டெவலப்பர்களை மேம்பாட்டு சுழற்சியில் முன்கூட்டியே பிழைகளைக் கண்டறியவும், குறியீடு பராமரிப்பை மேம்படுத்தவும், ஒட்டுமொத்த மென்பொருள் தரத்தை மேம்படுத்தவும் உதவுகிறது. டைப்ஸ்கிரிப்ட்டின் நன்மைகளைப் பயன்படுத்துவதற்கான மிக சக்திவாய்ந்த கருவிகளில் ஒன்று நிலையான குறியீடு பகுப்பாய்வு ஆகும், குறிப்பாக வகை வடிவங்களைப் பயன்படுத்துவதன் மூலம். இந்தப் பதிவு உங்கள் டைப்ஸ்கிரிப்ட் திட்டங்களை மேம்படுத்த நீங்கள் பயன்படுத்தக்கூடிய பல்வேறு நிலையான பகுப்பாய்வு நுட்பங்களையும் வகை வடிவங்களையும் ஆராயும்.

நிலையான குறியீடு பகுப்பாய்வு என்றால் என்ன?

நிலையான குறியீடு பகுப்பாய்வு என்பது ஒரு நிரல் இயக்கப்படுவதற்கு முன்பு மூலக் குறியீட்டை ஆய்வு செய்வதன் மூலம் பிழைத்திருத்தத்தின் ஒரு முறையாகும். இது குறியீட்டின் கட்டமைப்பு, சார்புகள் மற்றும் வகை குறிப்புகளை ஆய்வு செய்வதன் மூலம் சாத்தியமான பிழைகள், பாதுகாப்பு பாதிப்புகள் மற்றும் குறியீட்டு நடை மீறல்களைக் கண்டறியும். குறியீட்டை இயக்கி அதன் நடத்தையைக் கவனிக்கும் டைனமிக் பகுப்பாய்வைப் போலல்லாமல், நிலையான பகுப்பாய்வு இயக்க சூழல் அல்லாத சூழலில் குறியீட்டை ஆய்வு செய்கிறது. சோதனை செய்யும் போது உடனடியாகத் தெரியாத சிக்கல்களைக் கண்டறிய இது அனுமதிக்கிறது.

நிலையான பகுப்பாய்வு கருவிகள் மூலக் குறியீட்டை ஒரு Abstract Syntax Tree (AST) ஆகப் பிரிக்கும், இது குறியீட்டின் கட்டமைப்பின் மரப் பிரதிநிதித்துவம் ஆகும். பின்னர் அவை சாத்தியமான சிக்கல்களைக் கண்டறிய இந்த AST இல் விதிகள் மற்றும் வடிவங்களைப் பயன்படுத்துகின்றன. இந்த அணுகுமுறையின் நன்மை என்னவென்றால், குறியீட்டை இயக்கத் தேவையில்லாமல் பரந்த அளவிலான சிக்கல்களைக் கண்டறிய முடியும். இது மேம்பாட்டு சுழற்சியில் முன்கூட்டியே சிக்கல்களைக் கண்டறிய உதவுகிறது, அவை சரிசெய்ய கடினமாகவும் விலை உயர்ந்ததாகவும் மாறும்.

நிலையான குறியீடு பகுப்பாய்வின் நன்மைகள்

• முன்கூட்டிய பிழை கண்டறிதல்: ரன்டைமிற்கு முன் சாத்தியமான பிழைகள் மற்றும் வகை பிழைகளைக் கண்டறிந்து, பிழைத்திருத்த நேரத்தைக் குறைத்து, பயன்பாட்டின் ஸ்திரத்தன்மையை மேம்படுத்தவும்.
• மேம்படுத்தப்பட்ட குறியீடு தரம்: குறியீட்டு தரநிலைகள் மற்றும் சிறந்த நடைமுறைகளை அமல்படுத்துங்கள், இது மேலும் படிக்கக்கூடிய, பராமரிக்கக்கூடிய மற்றும் சீரான குறியீட்டிற்கு வழிவகுக்கும்.
• மேம்பட்ட பாதுகாப்பு: சுரண்டப்படுவதற்கு முன்பே, கிராஸ்-சைட் ஸ்கிரிப்டிங் (XSS) அல்லது SQL ஊடுருவல் போன்ற சாத்தியமான பாதுகாப்பு பாதிப்புகளைக் கண்டறியவும்.
• அதிகரித்த உற்பத்தித்திறன்: குறியீடு மதிப்புரைகளை தானியங்குபடுத்துங்கள் மற்றும் குறியீட்டை கைமுறையாக ஆய்வு செய்யும் நேரத்தைக் குறைக்கவும்.
• மறுசீரமைப்பு பாதுகாப்பு: மறுசீரமைப்பு மாற்றங்கள் புதிய பிழைகளை அறிமுகப்படுத்தாது அல்லது ஏற்கனவே உள்ள செயல்பாட்டை உடைக்காது என்பதை உறுதிப்படுத்தவும்.

டைப்ஸ்கிரிப்ட்டின் வகை அமைப்பு மற்றும் நிலையான பகுப்பாய்வு

டைப்ஸ்கிரிப்ட்டின் வகை அமைப்பு அதன் நிலையான பகுப்பாய்வு திறன்களுக்கு அடித்தளமாக அமைகிறது. வகை குறிப்புகளை வழங்குவதன் மூலம், டெவலப்பர்கள் மாறிகள், செயல்பாடு அளவுருக்கள் மற்றும் திரும்பும் மதிப்புகளின் எதிர்பார்க்கப்படும் வகைகளைக் குறிப்பிடலாம். டைப்ஸ்கிரிப்ட் கம்பைலர் பின்னர் இந்த தகவலை வகை சரிபார்ப்பைச் செய்யவும், சாத்தியமான வகை பிழைகளைக் கண்டறியவும் பயன்படுத்துகிறது. வகை அமைப்பு உங்கள் குறியீட்டின் வெவ்வேறு பகுதிகளுக்கு இடையே சிக்கலான உறவுகளை வெளிப்படுத்த அனுமதிக்கிறது, இது மேலும் வலுவான மற்றும் நம்பகமான பயன்பாடுகளுக்கு வழிவகுக்கிறது.

நிலையான பகுப்பாய்விற்கான டைப்ஸ்கிரிப்ட்டின் வகை அமைப்பின் முக்கிய அம்சங்கள்

• வகை குறிப்புகள்: மாறிகள், செயல்பாடு அளவுருக்கள் மற்றும் திரும்பும் மதிப்புகளின் வகைகளை வெளிப்படையாக அறிவிக்கவும்.
• வகை ஊகித்தல்: டைப்ஸ்கிரிப்ட் அவற்றின் பயன்பாட்டின் அடிப்படையில் மாறிகளின் வகைகளை தானாகவே ஊகிக்க முடியும், சில சந்தர்ப்பங்களில் வெளிப்படையான வகை குறிப்புகளின் தேவையை குறைக்கிறது.
• இடைமுகங்கள்: பொருள்கள் ஒரு ஒப்பந்தத்தை வரையறுக்கவும், ஒரு பொருள் கொண்டிருக்க வேண்டிய பண்புகள் மற்றும் முறைகளைக் குறிப்பிடவும்.
• வகுப்புகள்: மரபுரிமை, இணைத்தல் மற்றும் பல்லுருவாக்கத்திற்கான ஆதரவுடன், பொருள்கள் உருவாக்க ஒரு ப்ளூபிரிண்ட் வழங்கவும்.
• ஜெனரிக்ஸ்: வகைகளை வெளிப்படையாக குறிப்பிட வேண்டிய அவசியமின்றி, வெவ்வேறு வகைகளுடன் வேலை செய்யக்கூடிய குறியீட்டை எழுதவும்.
• யூனியன் வகைகள்: ஒரு மாறி வெவ்வேறு வகைகளின் மதிப்புகளை வைத்திருக்க அனுமதிக்கவும்.
• குறுக்கீடு வகைகள்: பல வகைகளை ஒரு வகையாக இணைக்கவும்.
• நிபந்தனை வகைகள்: பிற வகைகளைச் சார்ந்துள்ள வகைகளை வரையறுக்கவும்.
• மேப் செய்யப்பட்ட வகைகள்: ஏற்கனவே உள்ள வகைகளை புதிய வகைகளாக மாற்றவும்.
• பயன்பாட்டு வகைகள்: Partial, Readonly, மற்றும் Pick போன்ற உள்ளமைக்கப்பட்ட வகை மாற்றங்களின் தொகுப்பை வழங்கவும்.

டைப்ஸ்கிரிப்ட்டிற்கான நிலையான பகுப்பாய்வு கருவிகள்

டைப்ஸ்கிரிப்ட் குறியீட்டில் நிலையான பகுப்பாய்வைச் செய்ய பல கருவிகள் கிடைக்கின்றன. இந்த கருவிகள் உங்கள் குறியீட்டைப் பிழைகளுக்காக தானாகச் சரிபார்க்கவும், குறியீட்டு தரநிலைகளை அமல்படுத்தவும் உங்கள் மேம்பாட்டு பணிப்பாய்வில் ஒருங்கிணைக்கப்படலாம். நன்கு ஒருங்கிணைக்கப்பட்ட கருவித்தொகுப்பு உங்கள் குறியீட்டுத் தொகுப்பின் தரம் மற்றும் நிலைத்தன்மையை கணிசமாக மேம்படுத்த முடியும்.

பிரபலமான டைப்ஸ்கிரிப்ட் நிலையான பகுப்பாய்வு கருவிகள்

• ESLint: பரவலாகப் பயன்படுத்தப்படும் ஜாவாஸ்கிரிப்ட் மற்றும் டைப்ஸ்கிரிப்ட் லிண்டர், இது சாத்தியமான பிழைகளைக் கண்டறியவும், குறியீட்டு நடைகளை அமல்படுத்தவும், மேம்பாடுகளைப் பரிந்துரைக்கவும் முடியும். ESLint உயர்வாக உள்ளமைக்கக்கூடியது மற்றும் தனிப்பயன் விதிகளுடன் நீட்டிக்கப்படலாம்.
• TSLint (கைவிடப்பட்டது): TSLint டைப்ஸ்கிரிப்ட்டிற்கான முதன்மை லிண்டராக இருந்தபோதிலும், ESLintக்கு மாற்றாக கைவிடப்பட்டுள்ளது. தற்போதுள்ள TSLint உள்ளமைவுகளை ESLint க்கு மாற்றலாம்.
• SonarQube: டைப்ஸ்கிரிப்ட் உட்பட பல மொழிகளை ஆதரிக்கும் ஒரு விரிவான குறியீடு தர இயங்குதளம். SonarQube குறியீடு தரம், பாதுகாப்பு பாதிப்புகள் மற்றும் தொழில்நுட்ப கடன் பற்றிய விரிவான அறிக்கைகளை வழங்குகிறது.
• Codelyzer: டைப்ஸ்கிரிப்ட்டில் எழுதப்பட்ட ஏஞ்சல் திட்டங்களுக்கான ஒரு நிலையான பகுப்பாய்வு கருவி. Codelyzer ஏஞ்சல் குறியீட்டு தரநிலைகள் மற்றும் சிறந்த நடைமுறைகளை அமல்படுத்துகிறது.
• Prettier: ஒரு சீரான நடைக்கு ஏற்ப உங்கள் குறியீட்டை தானாக வடிவமைக்கும் ஒரு கருத்துடைய குறியீடு வடிவமைப்பான். குறியீட்டு நடை மற்றும் குறியீடு தரம் இரண்டையும் அமல்படுத்த Prettier ESLint உடன் ஒருங்கிணைக்கப்படலாம்.
• JSHint: சாத்தியமான பிழைகளைக் கண்டறிந்து குறியீட்டு நடைகளை அமல்படுத்தக்கூடிய மற்றொரு பிரபலமான ஜாவாஸ்கிரிப்ட் மற்றும் டைப்ஸ்கிரிப்ட் லிண்டர்.

டைப்ஸ்கிரிப்ட்டில் நிலையான பகுப்பாய்வு வகை வடிவங்கள்

வகை வடிவங்கள் என்பது டைப்ஸ்கிரிப்ட்டின் வகை அமைப்பைப் பயன்படுத்தும் பொதுவான நிரலாக்க சிக்கல்களுக்கான மீண்டும் பயன்படுத்தக்கூடிய தீர்வுகள் ஆகும். அவை குறியீடு வாசிப்புத்திறன், பராமரிப்பு மற்றும் சரியான தன்மையை மேம்படுத்த பயன்படுத்தப்படலாம். இந்த வடிவங்கள் பெரும்பாலும் ஜெனரிக்ஸ், நிபந்தனை வகைகள் மற்றும் மேப் செய்யப்பட்ட வகைகள் போன்ற மேம்பட்ட வகை அம்சங்களை உள்ளடக்குகின்றன.

1. பாகுபடுத்தப்பட்ட யூனியன்கள் (Discriminated Unions)

பாகுபடுத்தப்பட்ட யூனியன்கள், குறிக்கப்பட்ட யூனியன்கள் என்றும் அழைக்கப்படுகின்றன, இது பல வெவ்வேறு வகைகளில் ஒன்றாக இருக்கக்கூடிய ஒரு மதிப்பைப் பிரதிநிதித்துவப்படுத்த ஒரு சக்திவாய்ந்த வழியாகும். யூனியனில் உள்ள ஒவ்வொரு வகையும் ஒரு பொதுவான புலத்தைக் கொண்டுள்ளது, இது பாகுபடுத்தி என்று அழைக்கப்படுகிறது, இது மதிப்பைப் பிரதிநிதித்துவப்படுத்துகிறது. இது நீங்கள் எந்த வகை மதிப்பைக் கையாள்கிறீர்கள் என்பதை எளிதாகத் தீர்மானிக்கவும் அதற்கேற்ப கையாளவும் அனுமதிக்கிறது.

எடுத்துக்காட்டு: API பதிலைக் குறிப்பிடுதல்

தரவுகளுடன் கூடிய வெற்றிகரமான பதில் அல்லது பிழை செய்தியுடன் கூடிய பிழை பதிலைக் கொண்டுவரக்கூடிய ஒரு API ஐக் கவனியுங்கள். இதைப் பிரதிநிதித்துவப்படுத்த ஒரு பாகுபடுத்தப்பட்ட யூனியனைப் பயன்படுத்தலாம்:

interface Success {
  status: "success";
  data: any;
}

interface Error {
  status: "error";
  message: string;
}

type ApiResponse = Success | Error;

function handleResponse(response: ApiResponse) {
  if (response.status === "success") {
    console.log("Data:", response.data);
  } else {
    console.error("Error:", response.message);
  }
}

const successResponse: Success = { status: "success", data: { name: "John", age: 30 } };
const errorResponse: Error = { status: "error", message: "Invalid request" };

handleResponse(successResponse);
handleResponse(errorResponse);

இந்த எடுத்துக்காட்டில், status புலம் பாகுபடுத்தியாகும். handleResponse செயல்பாடு Success பதிலின் data புலத்தையும் Error பதிலின் message புலத்தையும் பாதுகாப்பாக அணுக முடியும், ஏனெனில் status புலத்தின் மதிப்பின் அடிப்படையில் நீங்கள் எந்த வகை மதிப்பைக் கையாளுகிறீர்கள் என்பதை டைப்ஸ்கிரிப்ட் அறியும்.

2. மாற்றத்திற்கான மேப் செய்யப்பட்ட வகைகள் (Mapped Types for Transformation)

மேப் செய்யப்பட்ட வகைகள் ஏற்கனவே உள்ள வகைகளை மாற்றுவதன் மூலம் புதிய வகைகளை உருவாக்க உங்களை அனுமதிக்கின்றன. ஏற்கனவே உள்ள வகையின் பண்புகளை மாற்றியமைக்கும் பயன்பாட்டு வகைகளை உருவாக்குவதற்கு அவை குறிப்பாக பயனுள்ளதாக இருக்கும். இது படிக்க முடியாத, பகுதியளவு அல்லது அவசியமான வகைகளை உருவாக்கப் பயன்படுத்தப்படலாம்.

எடுத்துக்காட்டு: பண்புகளை படிக்க முடியாததாக மாற்றுதல்

interface Person {
  name: string;
  age: number;
}

type ReadonlyPerson = Readonly<Person>;

const person: ReadonlyPerson = { name: "Alice", age: 25 };

// person.age = 30; // Error: Cannot assign to 'age' because it is a read-only property.

Readonly<T> பயன்பாட்டு வகை, T வகையின் அனைத்து பண்புகளையும் படிக்க முடியாததாக மாற்றுகிறது. இது பொருளின் பண்புகளின் தற்செயலான மாற்றத்தைத் தடுக்கிறது.

எடுத்துக்காட்டு: பண்புகளை விருப்பமானதாக மாற்றுதல்

interface Config {
  apiEndpoint: string;
  timeout: number;
  retries?: number;
}

type PartialConfig = Partial<Config>;

const partialConfig: PartialConfig = { apiEndpoint: "https://example.com" }; // OK

function initializeConfig(config: Config): void {
    console.log(`API Endpoint: ${config.apiEndpoint}, Timeout: ${config.timeout}, Retries: ${config.retries}`);
}

// This will throw an error because retries might be undefined.
//initializeConfig(partialConfig);

const completeConfig: Config = { apiEndpoint: "https://example.com", timeout: 5000, retries: 3 };

initializeConfig(completeConfig);

function processConfig(config: Partial<Config>) {
    const apiEndpoint = config.apiEndpoint ?? "";
    const timeout = config.timeout ?? 3000;
    const retries = config.retries ?? 1;
    console.log(`Config: apiEndpoint=${apiEndpoint}, timeout=${timeout}, retries=${retries}`);
}

processConfig(partialConfig);
processConfig(completeConfig);

Partial<T> பயன்பாட்டு வகை, T வகையின் அனைத்து பண்புகளையும் விருப்பமானதாக மாற்றுகிறது. ஒரு குறிப்பிட்ட வகையின் சில பண்புகளுடன் ஒரு பொருளை உருவாக்க விரும்பும்போது இது பயனுள்ளதாக இருக்கும்.

3. டைனமிக் வகை தீர்மானத்திற்கான நிபந்தனை வகைகள் (Conditional Types for Dynamic Type Determination)

நிபந்தனை வகைகள் மற்ற வகைகளைச் சார்ந்துள்ள வகைகளை வரையறுக்க உங்களை அனுமதிக்கின்றன. அவை ஒரு நிபந்தனை வெளிப்பாட்டின் அடிப்படையில் அமைந்துள்ளன, இது ஒரு நிபந்தனை உண்மையாக இருந்தால் ஒரு வகையாகவும், தவறாக இருந்தால் மற்றொரு வகையாகவும் மதிப்பிடப்படுகிறது. இது வெவ்வேறு சூழ்நிலைகளுக்கு ஏற்ப தகவமைக்கும் மிகவும் நெகிழ்வான வகை வரையறைகளை அனுமதிக்கிறது.

எடுத்துக்காட்டு: ஒரு செயல்பாட்டின் திரும்பும் வகையைப் பிரித்தெடுத்தல்

type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

function fetchData(url: string): Promise<string> {
  return Promise.resolve("Data from " + url);
}

type FetchDataReturnType = ReturnType<typeof fetchData>; // Promise<string>

function calculate(x:number, y:number): number {
    return x + y;
}

type CalculateReturnType = ReturnType<typeof calculate>; // number

ReturnType<T> பயன்பாட்டு வகை, ஒரு செயல்பாட்டு வகை T இன் திரும்பும் வகையைப் பிரித்தெடுக்கிறது. T ஒரு செயல்பாட்டு வகையாக இருந்தால், வகை அமைப்பு திரும்பும் வகை R ஐ ஊகித்து அதைத் தருகிறது. இல்லையெனில், அது any ஐத் தருகிறது.

4. வகைகளை சுருக்குவதற்கான வகை காவலர்கள் (Type Guards for Narrowing Types)

வகை காவலர்கள் என்பது ஒரு குறிப்பிட்ட நோக்கத்தில் ஒரு மாறியின் வகையை சுருக்கும் செயல்பாடுகள் ஆகும். அவை அதன் சுருக்கப்பட்ட வகையின் அடிப்படையில் ஒரு மாறியின் பண்புகள் மற்றும் முறைகளை பாதுகாப்பாக அணுக உங்களை அனுமதிக்கின்றன. யூனியன் வகைகள் அல்லது பல வகைகளாக இருக்கக்கூடிய மாறிகளுடன் பணிபுரியும்போது இது அவசியம்.

எடுத்துக்காட்டு: ஒரு யூனியனில் ஒரு குறிப்பிட்ட வகையை சரிபார்த்தல்

interface Circle {
  kind: "circle";
  radius: number;
}

interface Square {
  kind: "square";
  side: number;
}

type Shape = Circle | Square;

function isCircle(shape: Shape): shape is Circle {
  return shape.kind === "circle";
}

function getArea(shape: Shape): number {
  if (isCircle(shape)) {
    return Math.PI * shape.radius * shape.radius;
  } else {
    return shape.side * shape.side;
  }
}

const circle: Circle = { kind: "circle", radius: 5 };
const square: Square = { kind: "square", side: 10 };

console.log("Circle area:", getArea(circle));
console.log("Square area:", getArea(square));

isCircle செயல்பாடு ஒரு Shape ஒரு Circle ஆக உள்ளதா என்பதை சரிபார்க்கும் ஒரு வகை காவலர் ஆகும். if பிளாக்கிற்குள், shape ஒரு Circle என்பதை டைப்ஸ்கிரிப்ட் அறியும் மற்றும் radius பண்பை பாதுகாப்பாக அணுக அனுமதிக்கிறது.

5. வகை பாதுகாப்பிற்கான ஜெனரிக் கட்டுப்பாடுகள் (Generic Constraints for Type Safety)

ஜெனரிக் கட்டுப்பாடுகள் ஒரு ஜெனரிக் வகை அளவுருவுடன் பயன்படுத்தப்படக்கூடிய வகைகளைக் கட்டுப்படுத்த உங்களை அனுமதிக்கின்றன. இது ஜெனரிக் வகை குறிப்பிட்ட பண்புகள் அல்லது முறைகளைக் கொண்ட வகைகளுடன் மட்டுமே பயன்படுத்தப்படுவதை உறுதி செய்கிறது. இது வகை பாதுகாப்பை மேம்படுத்துகிறது மற்றும் மிகவும் குறிப்பிட்ட மற்றும் நம்பகமான குறியீட்டை எழுத உங்களை அனுமதிக்கிறது.

எடுத்துக்காட்டு: ஒரு ஜெனரிக் வகை ஒரு குறிப்பிட்ட பண்பைக் கொண்டிருப்பதை உறுதி செய்தல்

interface Lengthy {
  length: number;
}

function logLength<T extends Lengthy>(obj: T) {
  console.log(obj.length);
}

logLength("Hello"); // OK
logLength([1, 2, 3]); // OK

//logLength({ value: 123 }); // Error: Argument of type '{ value: number; }' is not assignable to parameter of type 'Lengthy'.
//  Property 'length' is missing in type '{ value: number; }' but required in type 'Lengthy'.

<T extends Lengthy> கட்டுப்பாடு, ஜெனரிக் வகை T ஒரு number வகை length பண்பைக் கொண்டிருக்க வேண்டும் என்பதை உறுதி செய்கிறது. இது length பண்பு இல்லாத வகைகளுடன் செயல்பாடு அழைக்கப்படுவதைத் தடுக்கிறது, வகை பாதுகாப்பை மேம்படுத்துகிறது.

6. பொதுவான செயல்பாடுகளுக்கான பயன்பாட்டு வகைகள் (Utility Types for Common Operations)

டைப்ஸ்கிரிப்ட் பொதுவான வகை மாற்றங்களைச் செய்யும் பல உள்ளமைக்கப்பட்ட பயன்பாட்டு வகைகளை வழங்குகிறது. இந்த வகைகள் உங்கள் குறியீட்டை எளிதாக்கலாம் மற்றும் அதை மேலும் படிக்கக்கூடியதாக மாற்றலாம். இவற்றில் `Partial`, `Readonly`, `Pick`, `Omit`, `Record` மற்றும் பிற அடங்கும்.

எடுத்துக்காட்டு: Pick மற்றும் Omit ஐப் பயன்படுத்துதல்

interface User {
  id: number;
  name: string;
  email: string;
  createdAt: Date;
}

// id மற்றும் name ஐ மட்டுமே கொண்ட ஒரு வகையை உருவாக்கவும்
type PublicUser = Pick<User, "id" | "name">;

// createdAt பண்பு இல்லாமல் ஒரு வகையை உருவாக்கவும்
type UserWithoutCreatedAt = Omit<User, "createdAt">;

const publicUser: PublicUser = { id: 123, name: "Bob" };
const userWithoutCreatedAt: UserWithoutCreatedAt = { id: 456, name: "Charlie", email: "charlie@example.com" };

console.log(publicUser);
console.log(userWithoutCreatedAt);

Pick<T, K> பயன்பாட்டு வகை, T வகையிலிருந்து K இல் குறிப்பிடப்பட்டுள்ள பண்புகளை மட்டுமே தேர்ந்தெடுப்பதன் மூலம் ஒரு புதிய வகையை உருவாக்குகிறது. Omit<T, K> பயன்பாட்டு வகை, T வகையிலிருந்து K இல் குறிப்பிடப்பட்டுள்ள பண்புகளை விலக்குவதன் மூலம் ஒரு புதிய வகையை உருவாக்குகிறது.

நடைமுறை பயன்பாடுகள் மற்றும் எடுத்துக்காட்டுகள்

இந்த வகை வடிவங்கள் வெறும் கோட்பாட்டு கருத்துக்கள் அல்ல; அவை நிஜ உலக டைப்ஸ்கிரிப்ட் திட்டங்களில் நடைமுறை பயன்பாடுகளைக் கொண்டுள்ளன. உங்கள் சொந்த திட்டங்களில் அவற்றை நீங்கள் எவ்வாறு பயன்படுத்தலாம் என்பதற்கான சில எடுத்துக்காட்டுகள் இங்கே:

1. API கிளையன்ட் உருவாக்கம்

ஒரு API கிளையன்டை உருவாக்கும் போது, API வழங்கக்கூடிய வெவ்வேறு வகை பதில்களைப் பிரதிநிதித்துவப்படுத்த பாகுபடுத்தப்பட்ட யூனியன்களைப் பயன்படுத்தலாம். API இன் கோரிக்கை மற்றும் பதில் உடல்களுக்கான வகைகளை உருவாக்க மேப் செய்யப்பட்ட வகைகள் மற்றும் நிபந்தனை வகைகளையும் நீங்கள் பயன்படுத்தலாம்.

2. படிவ சரிபார்ப்பு

படிவ தரவைச் சரிபார்க்கவும், அது சில நிபந்தனைகளை பூர்த்தி செய்வதை உறுதிப்படுத்தவும் வகை காவலர்கள் பயன்படுத்தப்படலாம். படிவ தரவு மற்றும் சரிபார்ப்பு பிழைகளுக்கான வகைகளை உருவாக்க மேப் செய்யப்பட்ட வகைகளையும் நீங்கள் பயன்படுத்தலாம்.

3. நிலை மேலாண்மை

ஒரு பயன்பாட்டின் வெவ்வேறு நிலைகளைப் பிரதிநிதித்துவப்படுத்த பாகுபடுத்தப்பட்ட யூனியன்கள் பயன்படுத்தப்படலாம். நிலையில் செய்யக்கூடிய செயல்களுக்கான வகைகளை வரையறுக்க நிபந்தனை வகைகளையும் நீங்கள் பயன்படுத்தலாம்.

4. தரவு மாற்ற பைப்லைன்கள்

செயல்பாட்டு கலவை மற்றும் ஜெனரிக்ஸ் மூலம் பைப்லைனாக மாற்றங்களின் வரிசையை நீங்கள் வரையறுக்கலாம், இது முழு செயல்முறையிலும் வகை பாதுகாப்பை உறுதி செய்கிறது. தரவு பல்வேறு நிலைகளில் செல்லும்போது தரவு சீராகவும் துல்லியமாகவும் இருப்பதை இது உறுதி செய்கிறது.

உங்கள் பணிப்பாய்வில் நிலையான பகுப்பாய்வை ஒருங்கிணைத்தல்

நிலையான பகுப்பாய்விலிருந்து அதிகப் பயனைப் பெற, உங்கள் மேம்பாட்டு பணிப்பாய்வில் அதை ஒருங்கிணைப்பது முக்கியம். உங்கள் குறியீட்டில் மாற்றங்களைச் செய்யும் போதெல்லாம் நிலையான பகுப்பாய்வு கருவிகளை தானாக இயக்குவதை இது குறிக்கிறது. உங்கள் பணிப்பாய்வில் நிலையான பகுப்பாய்வை ஒருங்கிணைப்பதற்கான சில வழிகள் இங்கே:

• எடிட்டர் ஒருங்கிணைப்பு: நீங்கள் தட்டச்சு செய்யும்போதே உங்கள் குறியீட்டில் நிகழ்நேர பின்னூட்டத்தைப் பெற ESLint மற்றும் Prettier ஐ உங்கள் குறியீடு எடிட்டரில் ஒருங்கிணைக்கவும்.
• Git Hooks: உங்கள் குறியீட்டை கமிட் செய்வதற்கு அல்லது புஷ் செய்வதற்கு முன் நிலையான பகுப்பாய்வு கருவிகளை இயக்க Git hooks ஐப் பயன்படுத்தவும். இது குறியீட்டு தரநிலைகளை மீறும் அல்லது சாத்தியமான பிழைகளைக் கொண்ட குறியீட்டை ரெப்போசிட்டரியில் கமிட் செய்வதைத் தடுக்கிறது.
• தொடர்ச்சியான ஒருங்கிணைப்பு (CI): ரெப்போசிட்டரிக்கு ஒரு புதிய கமிட் தள்ளப்படும் போதெல்லாம் உங்கள் குறியீட்டை தானாகச் சரிபார்க்க உங்கள் CI பைப்லைனில் நிலையான பகுப்பாய்வு கருவிகளை ஒருங்கிணைக்கவும். இது உற்பத்திக்கு வரிசைப்படுத்தப்படுவதற்கு முன்பு அனைத்து குறியீடு மாற்றங்களும் பிழைகள் மற்றும் குறியீட்டு நடை மீறல்களுக்காகச் சரிபார்க்கப்படுவதை உறுதி செய்கிறது. Jenkins, GitHub Actions, மற்றும் GitLab CI/CD போன்ற பிரபலமான CI/CD தளங்கள் இந்தக் கருவிகளுடன் ஒருங்கிணைப்பை ஆதரிக்கின்றன.

டைப்ஸ்கிரிப்ட் குறியீடு பகுப்பாய்விற்கான சிறந்த நடைமுறைகள்

டைப்ஸ்கிரிப்ட் குறியீடு பகுப்பாய்வைப் பயன்படுத்தும் போது பின்பற்ற வேண்டிய சில சிறந்த நடைமுறைகள் இங்கே:

• கடுமையான பயன்முறையை இயக்கவும்: மேலும் சாத்தியமான பிழைகளைக் கண்டறிய டைப்ஸ்கிரிப்ட்டின் கடுமையான பயன்முறையை இயக்கவும். கடுமையான பயன்முறை நீங்கள் மேலும் வலுவான மற்றும் நம்பகமான குறியீட்டை எழுத உதவும் பல கூடுதல் வகை சரிபார்ப்பு விதிகளை செயல்படுத்துகிறது.
• தெளிவான மற்றும் சுருக்கமான வகை குறிப்புகளை எழுதவும்: உங்கள் குறியீட்டைப் புரிந்துகொள்ளவும் பராமரிக்கவும் எளிதாக்க தெளிவான மற்றும் சுருக்கமான வகை குறிப்புகளைப் பயன்படுத்தவும்.
• ESLint மற்றும் Prettier ஐ உள்ளமைக்கவும்: குறியீட்டு தரநிலைகள் மற்றும் சிறந்த நடைமுறைகளை அமல்படுத்த ESLint மற்றும் Prettier ஐ உள்ளமைக்கவும். உங்கள் திட்டம் மற்றும் உங்கள் குழுவுக்குப் பொருத்தமான விதிகளின் தொகுப்பை நீங்கள் தேர்வு செய்வதை உறுதிசெய்யவும்.
• உங்கள் உள்ளமைவை தவறாமல் மதிப்பாய்வு செய்து புதுப்பிக்கவும்: உங்கள் திட்டம் உருவாகும்போது, அது இன்னும் பயனுள்ளதாக இருப்பதை உறுதிசெய்ய உங்கள் நிலையான பகுப்பாய்வு உள்ளமைவை தவறாமல் மதிப்பாய்வு செய்து புதுப்பிப்பது முக்கியம்.
• சிக்கல்களை உடனடியாக தீர்க்கவும்: நிலையான பகுப்பாய்வு கருவிகளால் அடையாளம் காணப்பட்ட எந்த சிக்கல்களையும் உடனடியாக தீர்க்கவும், அவை சரிசெய்ய கடினமாகவும் விலை உயர்ந்ததாகவும் மாறும் முன்பே.

முடிவுரை

டைப்ஸ்கிரிப்ட்டின் நிலையான பகுப்பாய்வு திறன்கள், வகை வடிவங்களின் சக்தியுடன் இணைந்து, உயர்தர, பராமரிக்கக்கூடிய மற்றும் நம்பகமான மென்பொருளை உருவாக்குவதற்கான ஒரு வலுவான அணுகுமுறையை வழங்குகின்றன. இந்த நுட்பங்களைப் பயன்படுத்துவதன் மூலம், டெவலப்பர்கள் பிழைகளை முன்கூட்டியே கண்டறியலாம், குறியீட்டு தரநிலைகளை அமல்படுத்தலாம் மற்றும் ஒட்டுமொத்த குறியீடு தரத்தை மேம்படுத்தலாம். உங்கள் மேம்பாட்டு பணிப்பாய்வில் நிலையான பகுப்பாய்வை ஒருங்கிணைப்பது உங்கள் டைப்ஸ்கிரிப்ட் திட்டங்களின் வெற்றிக்கு ஒரு முக்கிய படியாகும்.

எளிய வகை குறிப்புகள் முதல் பாகுபடுத்தப்பட்ட யூனியன்கள், மேப் செய்யப்பட்ட வகைகள் மற்றும் நிபந்தனை வகைகள் போன்ற மேம்பட்ட நுட்பங்கள் வரை, டைப்ஸ்கிரிப்ட் உங்கள் குறியீட்டின் வெவ்வேறு பகுதிகளுக்கு இடையே சிக்கலான உறவுகளை வெளிப்படுத்த ஒரு வளமான கருவித் தொகுப்பை வழங்குகிறது. இந்த கருவிகளை மாஸ்டரிங் செய்வதன் மூலமும் அவற்றை உங்கள் மேம்பாட்டு பணிப்பாய்வில் ஒருங்கிணைப்பதன் மூலமும், உங்கள் மென்பொருளின் தரம் மற்றும் நம்பகத்தன்மையை நீங்கள் கணிசமாக மேம்படுத்தலாம்.

ESLint போன்ற லிண்டர்கள் மற்றும் Prettier போன்ற வடிவமைப்பாளர்களின் சக்தியை குறைத்து மதிப்பிடாதீர்கள். இந்த கருவிகளை உங்கள் எடிட்டர் மற்றும் CI/CD பைப்லைனில் ஒருங்கிணைப்பது, குறியீட்டு நடைகள் மற்றும் சிறந்த நடைமுறைகளை தானாக அமல்படுத்த உதவும், இது மேலும் சீரான மற்றும் பராமரிக்கக்கூடிய குறியீட்டிற்கு வழிவகுக்கும். உங்கள் நிலையான பகுப்பாய்வு உள்ளமைவின் வழக்கமான மதிப்பாய்வுகள் மற்றும் புகாரளிக்கப்பட்ட சிக்கல்களுக்கு உடனடி கவனம் செலுத்துவதும் உங்கள் குறியீடு உயர்தரமாகவும் சாத்தியமான பிழைகளற்றதாகவும் இருப்பதை உறுதிசெய்ய முக்கியமாகும்.

இறுதியில், நிலையான பகுப்பாய்வு மற்றும் வகை வடிவங்களில் முதலீடு செய்வது உங்கள் டைப்ஸ்கிரிப்ட் திட்டங்களின் நீண்டகால ஆரோக்கியம் மற்றும் வெற்றிக்கு ஒரு முதலீடாகும். இந்த நுட்பங்களை ஏற்றுக்கொள்வதன் மூலம், செயல்பாட்டுடன் மட்டுமல்லாமல், வலுவான, பராமரிக்கக்கூடிய மற்றும் வேலை செய்ய இன்பமான மென்பொருளை நீங்கள் உருவாக்க முடியும்.